package com.supersit.GZFDA.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.os.Environment;
import android.util.Log;
import android.widget.Toast;

public class FileUtils {
	/***
	 * SD目录
	 */
	private String SDCardRoot;

	// 使用构造函数获得SD卡的目录
	public FileUtils() {
		// 得到当前外部存储设备的目录名
		SDCardRoot = Environment.getExternalStorageDirectory()
				.getAbsolutePath();
	}

	/***
	 * 在SD卡上创建文件
	 * 
	 * @param fileName
	 *            文件名
	 * @param dir
	 *            文件存储目录
	 * @return 文件
	 * @throws IOException
	 */
	public File createFileInSDCard(String fileName, String dir)
			throws IOException {
		// File.separator是系统有关的默认名称分隔符“/”
		File file = new File(SDCardRoot + File.separator + dir + File.separator
				+ fileName);
		// System.out.println(file);
		file.createNewFile();
		return file;
	}

	/**
	 * 在SD卡上创建目录
	 * 
	 * @param dir
	 *            目录名称
	 * @return 返回目录
	 */
	public File createSDDir(String dir) {
		File dirFile = new File(SDCardRoot + File.separator + dir
				+ File.separator);
		// System.out.println(dirFile);
		dirFile.mkdirs();
		return dirFile;
	}

	/***
	 * 判断文件是否存在
	 * 
	 * @param fileNameString
	 *            文件名
	 * @param pathString
	 *            文件路径
	 * @return 存在返回true 不存在返回false
	 */
	public boolean isFileExist(String fileNameString, String path) {
		File file = new File(SDCardRoot + "/" + path + File.separator
				+ fileNameString);
		// System.out.println("isExist ->" + file);
		return file.exists();
	}

	/***
	 * 将InputStream里面的数据写入到SD卡的文件中
	 * 
	 * @param path
	 *            文件的路径
	 * @param fileNameString
	 *            文件名
	 * @param inputStream
	 *            数据流
	 * @return
	 */
	public File write2SDFromInput(String path, String fileNameString,
			InputStream inputStream) {
		File file = null;
		OutputStream outputStream = null;
		try {
			createSDDir(path);
			file = createFileInSDCard(fileNameString, path);

			outputStream = new FileOutputStream(file);
			// 创建一个4*1024大小的缓冲区
			byte buffer[] = new byte[4 * 1024];
			int temp;
			// 循环读取InputStream里的数据
			while ((temp = inputStream.read(buffer)) != -1) {
				// 把流按照buffer的大小写入到文件中
				outputStream.write(buffer, 0, temp);

			}
			// 提交缓冲区的内容
			outputStream.flush();

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				outputStream.close();

			} catch (Exception e2) {
				// TODO: handle exception
				e2.printStackTrace();
			}
		}

		return file;

	}

	// 新建文件夹
	public static String makeDirs(String fileName) {
		String SDCardRoot = Environment.getExternalStorageDirectory()
				.getAbsolutePath();
		String fileDir = SDCardRoot + File.separator + "GZFAD";
		File file = new File(fileDir);
		if (!file.exists()) {
			file.mkdir();
		}
		String filePath = SDCardRoot + File.separator + "GZFAD"
				+ File.separator + fileName;
		File dirPath = new File(filePath);
		if (!dirPath.exists()) {
			dirPath.mkdir();
			Log.d("tag", "文件夹创建成功");
		} else {
			Log.d("tag", "文件夹已存在，删除之后再新建");
			if (!fileName.equals("temp")) {
				delFolder(filePath);
				dirPath.mkdir();
			}
		}

		return filePath;

	}

	// 新建文件夹
	public static String makePhotoDirs() {
		String SDCardRoot = Environment.getExternalStorageDirectory()
				.getAbsolutePath();
		String fileDir = SDCardRoot + File.separator + "GZFAD";
		File file = new File(fileDir);
		if (!file.exists()) {
			file.mkdir();
		}
		String filePath = SDCardRoot + File.separator + "GZFAD";
		File dirPath = new File(filePath);
		if (!dirPath.exists()) {
			dirPath.mkdir();
			Log.d("tag", "文件夹创建成功");
		} else {

		}

		return filePath;

	}

	// 删除指定文件夹下所有文件
	// param path 文件夹完整绝对路径
	public static boolean delAllFile(String path) {
		boolean flag = false;
		File file = new File(path);
		if (!file.exists()) {
			return flag;
		}
		if (!file.isDirectory()) {
			return flag;
		}
		String[] tempList = file.list();
		File temp = null;
		for (int i = 0; i < tempList.length; i++) {
			if (path.endsWith(File.separator)) {
				temp = new File(path + tempList[i]);
			} else {
				temp = new File(path + File.separator + tempList[i]);
			}
			if (temp.isFile()) {
				temp.delete();
			}
			if (temp.isDirectory()) {
				delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
				delFolder(path + "/" + tempList[i]);// 再删除空文件夹
				flag = true;
			}
		}
		return flag;
	}

	// 删除文件夹
	// param folderPath 文件夹完整绝对路径

	public static void delFolder(String folderPath) {
		try {
			delAllFile(folderPath); // 删除完里面所有内容
			String filePath = folderPath;
			filePath = filePath.toString();
			java.io.File myFilePath = new java.io.File(filePath);
			myFilePath.delete(); // 删除空文件夹
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获取路径文件夹下的所有文件名
	 * 
	 * @param path
	 * @return
	 */
	public static List<String> getFileNames(String path) {
		List<String> list = new ArrayList<String>();
		File file = new File(path);
		File[] tempList = file.listFiles();
		if (tempList != null) {
			for (int i = 0; i < tempList.length; i++) {
				if (tempList[i].isFile()) {
					String name = path + tempList[i].getName();
					list.add(name);
				}
			}
		}

		return list;
	}

	/**
	 * 重命名文件夹
	 * 
	 * @param fromDir
	 * @param toDir
	 */

	public static boolean renameDirectory(String fromDir, String toDir) {
		boolean flag;
		File from = new File(fromDir);

		if (!from.exists() || !from.isDirectory()) {
			System.out.println("Directory does not exist: " + fromDir);
			return false;
		}

		File to = new File(toDir);

		// Rename
		if (from.renameTo(to))
			System.out.println("Success!");
		else
			System.out.println("Error");
		return flag = from.renameTo(to);

	}

	/**
	 * 复制文件或文件夹
	 * 
	 * @param srcPath
	 * @param destDir
	 *            目标文件所在的目录
	 * @return
	 */
	public static boolean copyGeneralFile(String srcPath, String destDir) {
		boolean flag = false;
		File file = new File(srcPath);
		if (!file.exists()) {
			System.out.println("源文件或源文件夹不存在!");
			return false;
		}
		if (file.isFile()) { // 源文件
			System.out.println("下面进行文件复制!");
			flag = copyFile(srcPath, destDir);
		} else if (file.isDirectory()) {
			System.out.println("下面进行文件夹复制!");
			flag = copyDirectory(srcPath, destDir);
		}

		return flag;
	}

	/**
	 * 复制文件
	 * 
	 * @param srcPath
	 *            源文件绝对路径
	 * @param destDir
	 *            目标文件所在目录
	 * @return boolean
	 */
	private static boolean copyFile(String srcPath, String destDir) {
		boolean flag = false;

		File srcFile = new File(srcPath);
		if (!srcFile.exists()) { // 源文件不存在
			System.out.println("源文件不存在");
			return false;
		}
		// 获取待复制文件的文件名
		String fileName = srcPath
				.substring(srcPath.lastIndexOf(File.separator));
		String destPath = destDir + fileName;
		if (destPath.equals(srcPath)) { // 源文件路径和目标文件路径重复
			System.out.println("源文件路径和目标文件路径重复!");
			return false;
		}
		File destFile = new File(destPath);
		if (destFile.exists() && destFile.isFile()) { // 该路径下已经有一个同名文件
			System.out.println("目标目录下已有同名文件!");
			return false;
		}

		File destFileDir = new File(destDir);
		destFileDir.mkdirs();
		try {
			FileInputStream fis = new FileInputStream(srcPath);
			FileOutputStream fos = new FileOutputStream(destFile);
			byte[] buf = new byte[1024];
			int c;
			while ((c = fis.read(buf)) != -1) {
				fos.write(buf, 0, c);
			}
			fis.close();
			fos.close();

			flag = true;
		} catch (IOException e) {
			//
		}

		if (flag) {
			System.out.println("复制文件成功!");
		}

		return flag;
	}

	/**
	 * 
	 * @param srcPath
	 *            源文件夹路径
	 * @param destPath
	 *            目标文件夹所在目录
	 * @return
	 */
	private static boolean copyDirectory(String srcPath, String destDir) {
		System.out.println("复制文件夹开始!");
		boolean flag = false;

		File srcFile = new File(srcPath);
		if (!srcFile.exists()) { // 源文件夹不存在
			System.out.println("源文件夹不存在");
			return false;
		}
		// 获得待复制的文件夹的名字，比如待复制的文件夹为"E://dir"则获取的名字为"dir"
		String dirName = getDirName(srcPath);
		// 目标文件夹的完整路径
		String destPath = destDir + File.separator + dirName;
		// System.out.println("目标文件夹的完整路径为：" + destPath);

		if (destPath.equals(srcPath)) {
			System.out.println("目标文件夹与源文件夹重复");
			return false;
		}
		File destDirFile = new File(destPath);
		if (destDirFile.exists()) { // 目标位置有一个同名文件夹
			System.out.println("目标位置已有同名文件夹!");
			return false;
		}
		destDirFile.mkdirs(); // 生成目录

		File[] fileList = srcFile.listFiles(); // 获取源文件夹下的子文件和子文件夹
		if (fileList.length == 0) { // 如果源文件夹为空目录则直接设置flag为true，这一步非常隐蔽，debug了很久
			flag = true;
		} else {
			for (File temp : fileList) {
				if (temp.isFile()) { // 文件
					flag = copyFile(temp.getAbsolutePath(), destPath);
				} else if (temp.isDirectory()) { // 文件夹
					flag = copyDirectory(temp.getAbsolutePath(), destPath);
				}
				if (!flag) {
					break;
				}
			}
		}

		if (flag) {
			System.out.println("复制文件夹成功!");
		}

		return flag;
	}

	/**
	 * 获取待复制文件夹的文件夹名
	 * 
	 * @param dir
	 * @return String
	 */
	private static String getDirName(String dir) {
		if (dir.endsWith(File.separator)) { // 如果文件夹路径以"//"结尾，则先去除末尾的"//"
			dir = dir.substring(0, dir.lastIndexOf(File.separator));
		}
		return dir.substring(dir.lastIndexOf(File.separator) + 1);
	}

	/**
	 * 删除文件或文件夹
	 * 
	 * @param path
	 *            待删除的文件的绝对路径
	 * @return boolean
	 */
	public static boolean deleteGeneralFile(String path) {
		boolean flag = false;

		File file = new File(path);
		if (!file.exists()) { // 文件不存在
			System.out.println("要删除的文件不存在！");
		}

		if (file.isDirectory()) { // 如果是目录，则单独处理
			flag = deleteDirectory(file.getAbsolutePath());
		} else if (file.isFile()) {
			flag = deleteFile(file);
		}

		if (flag) {
			System.out.println("删除文件或文件夹成功!");
		}

		return flag;
	}

	/**
	 * 删除文件
	 * 
	 * @param file
	 * @return boolean
	 */
	private static boolean deleteFile(File file) {
		return file.delete();
	}

	/**
	 * 删除目录及其下面的所有子文件和子文件夹，注意一个目录下如果还有其他文件或文件夹
	 * 则直接调用delete方法是不行的，必须待其子文件和子文件夹完全删除了才能够调用delete
	 * 
	 * @param path
	 *            path为该目录的路径
	 */
	private static boolean deleteDirectory(String path) {
		boolean flag = true;
		File dirFile = new File(path);
		if (!dirFile.isDirectory()) {
			return flag;
		}
		File[] files = dirFile.listFiles();
		for (File file : files) { // 删除该文件夹下的文件和文件夹
			// Delete file.
			if (file.isFile()) {
				flag = deleteFile(file);
			} else if (file.isDirectory()) {// Delete folder
				flag = deleteDirectory(file.getAbsolutePath());
			}
			if (!flag) { // 只要有一个失败就立刻不再继续
				break;
			}
		}
		flag = dirFile.delete(); // 删除空目录
		return flag;
	}

	/**
	 * 由上面方法延伸出剪切方法：复制+删除
	 * 
	 * @param destDir
	 *            同上
	 */
	public static boolean cutGeneralFile(String srcPath, String destDir) {
		if (!copyGeneralFile(srcPath, destDir)) {
			System.out.println("复制失败导致剪切失败!");
			return false;
		}
		if (!deleteGeneralFile(srcPath)) {
			System.out.println("删除源文件(文件夹)失败导致剪切失败!");
			return false;
		}

		System.out.println("剪切成功!");
		return true;
	}

	/**
	 * 判断文件夹是否为空
	 * 
	 * @param path
	 * @return
	 */
	public static boolean dirIsNull(String path) {
		boolean flag = false;
		File file = new File(path);
		if (file.isDirectory()) {
			String[] files = file.list();
			if (files.length > 0) {
				flag = false;
			} else {
				flag = true;
			}
		}

		return flag;

	}

	/**
	 * 
	 * @param fromFile
	 *            被复制的文件
	 * @param toFile
	 *            复制的目录文件
	 * @param rewrite
	 *            是否重新创建文件
	 * 
	 *            <p>
	 *            文件的复制操作方法
	 */
	public static void copyfile(File fromFile, File toFile, Boolean rewrite) {

		if (!fromFile.exists()) {
			return;
		}

		if (!fromFile.isFile()) {
			return;
		}
		if (!fromFile.canRead()) {
			return;
		}
		if (!toFile.getParentFile().exists()) {
			toFile.getParentFile().mkdirs();
		}
		if (toFile.exists() && rewrite) {
			toFile.delete();
		}

		try {
			FileInputStream fosfrom = new FileInputStream(fromFile);
			FileOutputStream fosto = new FileOutputStream(toFile);

			byte[] buffer = new byte[1024 * 2];
			int len;
			while ((len = fosfrom.read(buffer)) != -1) {
				fosto.write(buffer, 0, len);
			}
			// 关闭输入、输出流
			fosfrom.close();
			fosto.close();

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	/**
	 * 在FileOutputStream创建一个流文件路径时或者是对一个File文件路径直接操作时，可先创建文件的路径
	 * 
	 * @param filePath
	 */
	public static void makeRootDirectory(String filePath) {
		File file = null;
		try {
			file = new File(filePath);
			if (!file.exists()) {
				file.mkdir();
			}
		} catch (Exception e) {

		}
	}
}
